Despliegue de los resultados Medellín¶
In [1]:
# Importar paquetes
import matplotlib.pyplot as plt
import datetime
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from fbprophet import Prophet
import warnings
warnings.filterwarnings('ignore')
import seaborn as sns
!pip install plotly
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import datetime as dt
from datetime import timedelta
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score,silhouette_samples
from sklearn.linear_model import LinearRegression,Ridge,Lasso
from sklearn.svm import SVR
from sklearn.metrics import mean_squared_error,r2_score
from sklearn.preprocessing import PolynomialFeatures
import statsmodels.api as sm
from statsmodels.tsa.api import Holt,SimpleExpSmoothing,ExponentialSmoothing
from statsmodels.tsa.stattools import adfuller
std=StandardScaler()
from pmdarima.arima import auto_arima
pd.set_option('display.float_format', lambda x: '%.6f' % x)
In [2]:
dfCovid = pd.read_csv('https://www.datos.gov.co/api/views/gt2j-8ykr/rows.csv')
In [3]:
dfCovid.head(10)
Out[3]:
In [4]:
# Modificar el tipo de datos para las variables de fechas.
dfCovid['Fecha de notificación']= pd.to_datetime(dfCovid['Fecha de notificación'])
dfCovid[ 'Fecha de muerte']= pd.to_datetime(dfCovid['Fecha de muerte'])
dfCovid['Fecha diagnostico']= pd.to_datetime(dfCovid['Fecha diagnostico'])
dfCovid['Fecha recuperado']= pd.to_datetime(dfCovid['Fecha recuperado'])
dfCovid['fecha reporte web']= pd.to_datetime(dfCovid['fecha reporte web'])
In [5]:
# Limpieza de los resultados para el atributo atención.
dfCovid['atención'].unique()
dfCovid['atención']= dfCovid['atención'].replace({'CASA':'Casa'})
dfCovid['atención']= dfCovid['atención'].fillna('No especifica')
In [6]:
fechas= sorted(pd.concat([dfCovid['Fecha de notificación'],dfCovid['Fecha diagnostico'],dfCovid['Fecha de muerte'],dfCovid['Fecha recuperado'],dfCovid['fecha reporte web']]).unique())
fechas=np.arange(min(fechas),max(fechas),np.timedelta64(86400000000000,'ns'))
dfCovid_Nuevo=pd.DataFrame({'Fecha':fechas})
dfCovid_Nuevo['Muertos']=np.zeros(len(dfCovid_Nuevo))
dfCovid_Nuevo['Confirmados']=np.zeros(len(dfCovid_Nuevo))
dfCovid_Nuevo['Recuperados']=np.zeros(len(dfCovid_Nuevo))
dfCovid_Nuevo
Out[6]:
MEDELLÍN¶
In [7]:
# Se filtra por la ciudad de interés
nombre='Medellín'
x=dfCovid[dfCovid['Ciudad de ubicación']==nombre].sort_values(by='Fecha de muerte',ascending=False)
x=x[['ID de caso','atención','fecha reporte web','Fecha de muerte','Fecha de notificación','Fecha diagnostico','Fecha recuperado']]
x
Out[7]:
In [8]:
# Se construye el Data Set Covid-19
#Conteo de muertos
m=x[x['atención']=='Fallecido'].groupby('Fecha de muerte').count()
m=pd.DataFrame({'Fecha':m.index.values,'Muertos':[n for n in m.values[:,0]]})
#Conteo de Confirmados
c=x.groupby('Fecha de notificación').count()
c=pd.DataFrame({'Fecha':c.index.values,'Confirmados':[n for n in c.values[:,0]]})
#Conteo Recuperados
r=x.groupby('Fecha recuperado').count()
r=pd.DataFrame({'Fecha':r.index.values,'Recuperados':[n for n in r.values[:,0]]})
df_Nuevo=pd.concat([dfCovid_Nuevo,c,m,r])
df_Nuevo.sort_values(by='Fecha',ascending=True)
df_Nuevo=df_Nuevo.groupby('Fecha').sum().sort_values(by='Fecha',ascending=True)
def acum(df,Col):
m=df[Col].values
d=0
L=[]
for n in m:
d=d+n
L.append(d)
return L
df_Nuevo['Acum_muertos']=acum(df_Nuevo,'Muertos')
df_Nuevo['Acum_confirmados']=acum(df_Nuevo,'Confirmados')
df_Nuevo['Acum_Recuperados']=acum(df_Nuevo,'Recuperados')
df_Nuevo['Acum_Activos']=df_Nuevo['Acum_confirmados']-df_Nuevo['Acum_Recuperados']-df_Nuevo['Acum_muertos']
df_Nuevo
Out[8]:
ANÁLISIS EXPLORATORIO DE DATOS
In [9]:
print("Estructura del dataset: ",df_Nuevo.shape)
print("Variables con valores nulos",df_Nuevo.isnull().sum())
print("Tipo de variables del dataset",df_Nuevo.dtypes)
In [10]:
print("Información Básica")
df_Nuevo.iloc(0)[-1]
Out[10]:
In [11]:
fig=px.bar(x=df_Nuevo.index,y=df_Nuevo["Acum_Activos"])
fig.update_layout(title="Distribución del número de casos activos en Medellín ",
xaxis_title="Fecha",yaxis_title="Número de casos en Medellín",)
fig.show()
In [12]:
fig=px.bar(x=df_Nuevo.index,y=df_Nuevo["Acum_Recuperados"]+df_Nuevo["Acum_muertos"])
fig.update_layout(title="Distribución del número de casos cerrados en Medellín",
xaxis_title="Fecha",yaxis_title="Número de casos en Medellín")
fig.show()
In [13]:
df_Nuevo["WeekOfYear"]=df_Nuevo.index.weekofyear
week_num=[]
weekwise_confirmed=[]
weekwise_recovered=[]
weekwise_deaths=[]
weekwise_active=[]
w=1
for i in list(df_Nuevo["WeekOfYear"].unique()):
weekwise_confirmed.append(df_Nuevo[df_Nuevo["WeekOfYear"]==i]["Acum_confirmados"].iloc[-1])
weekwise_recovered.append(df_Nuevo[df_Nuevo["WeekOfYear"]==i]["Acum_Recuperados"].iloc[-1])
weekwise_deaths.append(df_Nuevo[df_Nuevo["WeekOfYear"]==i]["Acum_muertos"].iloc[-1])
weekwise_active.append(df_Nuevo[df_Nuevo["WeekOfYear"]==i]["Acum_Activos"].iloc[-1])
week_num.append(w)
w=w+1
fig=go.Figure()
fig.add_trace(go.Scatter(x=week_num, y=weekwise_confirmed,
mode='lines+markers',
name='Crecimiento semanal de los casos confirmados'))
fig.add_trace(go.Scatter(x=week_num, y=weekwise_recovered,
mode='lines+markers',
name='Crecimiento semanal de los casos recuperados'))
fig.add_trace(go.Scatter(x=week_num, y=weekwise_deaths,
mode='lines+markers',
name='Crecimiento semanal de los casos de muerte'))
fig.add_trace(go.Scatter(x=week_num, y=weekwise_active,
mode='lines+markers',
name='Crecimiento semanal de los casos Activos'))
fig.update_layout(title="Crecimiento semanal de diferentes tipos de casos en Medellín",
xaxis_title="Número de semanas",yaxis_title="Número de casos",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
In [14]:
fig, (ax1,ax2) = plt.subplots(1, 2,figsize=(15,5))
sns.barplot(x=week_num,y=pd.Series(weekwise_confirmed).diff().fillna(0),ax=ax1)
sns.barplot(x=week_num,y=pd.Series(weekwise_deaths).diff().fillna(0),ax=ax2)
ax1.set_xlabel("Número de semanas")
ax2.set_xlabel("Número de semanas")
ax1.set_ylabel("Número de casos confirmados")
ax2.set_ylabel("Número de casos de fallecidos")
ax1.set_title("Aumento semanal del número de casos confirmados en Medellín")
ax2.set_title("Aumento semanal del número de casos de muerte en Medellín")
Out[14]:
Tasa de crecimiento de los casos confirmados, recuperados y de muerte¶
In [15]:
fig=go.Figure()
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_confirmados"],
mode='lines+markers',
name='Casos confirmados'))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_Recuperados"],
mode='lines+markers',
name='Casos Recuperados'))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_muertos"],
mode='lines+markers',
name='Casos de muertes'))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_Activos"],
mode='lines+markers',
name='Casos Activos'))
fig.update_layout(title="Crecimiento de los diferentes tipos de casos en Medellín",
xaxis_title="Fecha",yaxis_title="Número de casos",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
Análisis de la tasa de moralidad y recuperación¶
In [16]:
df_Nuevo["Tasa de mortalidad"]=(df_Nuevo["Acum_muertos"]/df_Nuevo["Acum_confirmados"])*100
df_Nuevo["Tasa de Recuperacion"]=(df_Nuevo["Acum_Recuperados"]/df_Nuevo["Acum_confirmados"])*100
df_Nuevo["Casos Cerrados"]=df_Nuevo["Acum_Recuperados"]+df_Nuevo["Acum_muertos"]
print("Tasa de mortalidad media",df_Nuevo["Tasa de mortalidad"].mean())
print("Tasa de mortalidad media",df_Nuevo["Tasa de mortalidad"].median())
print("Promedio de la tasa de recuperación",df_Nuevo["Tasa de Recuperacion"].mean())
print("Tasa de recuperación media",df_Nuevo["Tasa de Recuperacion"].median())
#Plotting Mortality and Recovery Rate
fig = make_subplots(rows=2, cols=1,
subplot_titles=("Tasa de Recuperacion", "Tasa de mortalidad"))
fig.add_trace(
go.Scatter(x=df_Nuevo.index, y=(df_Nuevo["Acum_Recuperados"]/df_Nuevo["Acum_confirmados"])*100,name="Tasa de Recuperacion"),
row=1, col=1
)
fig.add_trace(
go.Scatter(x=df_Nuevo.index, y=(df_Nuevo["Acum_muertos"]/df_Nuevo["Acum_confirmados"])*100,name="Tasa de mortalidad"),
row=2, col=1
)
fig.update_layout(height=1000,legend=dict(x=-0.1,y=1.2,traceorder="normal"))
fig.update_xaxes(title_text="Fecha", row=1, col=1)
fig.update_yaxes(title_text="Tasa de Recuperacion en Medellín", row=1, col=1)
fig.update_xaxes(title_text="Fecha", row=1, col=2)
fig.update_yaxes(title_text="Tasa de mortalidad en Medellín", row=1, col=2)
fig.show()
In [17]:
print("Aumento medio del número de casos confirmados cada día en Medellín: ",np.round(df_Nuevo["Acum_confirmados"].diff().fillna(0).mean()))
print("Aumento medio del número de casos recuperados cada día en Medellín: ",np.round(df_Nuevo["Acum_Recuperados"].diff().fillna(0).mean()))
print("Aumento promedio del número de casos de muerte cada día en Medellín: ",np.round(df_Nuevo["Acum_muertos"].diff().fillna(0).mean()))
print("Aumento promedio del número de casos de activos cada día en Medellín: ",np.round(df_Nuevo["Acum_Activos"].diff().fillna(0).mean()))
fig=go.Figure()
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_confirmados"].diff().fillna(0),mode='lines+markers',
name='Casos de confirmados'))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_Recuperados"].diff().fillna(0),mode='lines+markers',
name='Casos de recuperados'))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_muertos"].diff().fillna(0),mode='lines+markers',
name='Casos de Muerte'))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_Activos"].diff().fillna(0),mode='lines+markers',
name='Casos Activos'))
fig.update_layout(title="Aumento diario de los diferentes tipos de casos en Medellín",
xaxis_title="Fecha",yaxis_title="Número de casos",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
In [18]:
fig=go.Figure()
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_confirmados"].diff().rolling(window=7).mean(),mode='lines+markers',
name='Casos Confirmados'))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_Recuperados"].diff().rolling(window=7).mean(),mode='lines+markers',
name='Casos Recuperados'))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_muertos"].diff().rolling(window=7).mean(),mode='lines+markers',
name='Casos Fallecidos'))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_Activos"].diff().rolling(window=7).mean(),mode='lines+markers',
name='Casos Activos'))
fig.update_layout(title="Media móvil por cada 7 días de los casos confirmados, recuperados y de muerte en Medellín",
xaxis_title="Fecha",yaxis_title="Número de casos",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
In [19]:
print("Promedio de crecimiento medio del número de casos confirmados en Medellín: ",(df_Nuevo["Acum_confirmados"]/df_Nuevo["Acum_confirmados"].shift()).mean())
print("Mediana de crecimiento medio del número de casos confirmados en Medellín: ",(df_Nuevo["Acum_confirmados"]/df_Nuevo["Acum_confirmados"].shift()).median())
print("Promedio de crecimiento medio del número de casos recuperados en Medellín: ",(df_Nuevo["Acum_Recuperados"]/df_Nuevo["Acum_Recuperados"].shift()).mean())
print("Mediana de crecimiento medio del número de casos recuperados en Medellín: ",(df_Nuevo["Acum_Recuperados"]/df_Nuevo["Acum_Recuperados"].shift()).median())
print("Promedio de crecimiento medio del número de casos de muerte en Medellín: ",(df_Nuevo["Acum_muertos"]/df_Nuevo["Acum_muertos"].shift()).mean())
print("Mediana de crecimiento medio del número de casos de muerte en Medellín: ",(df_Nuevo["Acum_muertos"]/df_Nuevo["Acum_muertos"].shift()).median())
fig=go.Figure()
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_confirmados"]/df_Nuevo["Acum_confirmados"].shift(),
mode='lines',
name='Factor de crecimiento de los casos confirmados'))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_Recuperados"]/df_Nuevo["Acum_Recuperados"].shift(),
mode='lines',
name='Factor de crecimiento de los casos recuperados'))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_muertos"]/df_Nuevo["Acum_muertos"].shift(),
mode='lines',
name='Factor de crecimiento de los casos de muerte'))
fig.update_layout(title="Factor de crecimiento en función de la fecha de los diferentes tipos de casos en Medellín",
xaxis_title="Fecha",yaxis_title="Factor de crecimiento",
legend=dict(x=0,y=-0.4,traceorder="normal"))
fig.show()
MODELOS DE PREDICCIÓN MEDELLÍN¶
CASOS CONFIRMADOS¶
Modelo de regresión lineal para la predicción¶
In [20]:
df_Nuevo["Fecha"]=df_Nuevo.index-df_Nuevo.index[0]
df_Nuevo["Fecha"]=df_Nuevo["Fecha"].dt.days
In [21]:
train_ml=df_Nuevo.iloc[:int(df_Nuevo.shape[0]*0.96)]
valid_ml=df_Nuevo.iloc[int(df_Nuevo.shape[0]*0.96):]
model_scores=[]
In [22]:
lin_reg=LinearRegression(normalize=True)
In [23]:
lin_reg.fit(np.array(train_ml["Fecha"]).reshape(-1,1),np.array(train_ml["Acum_confirmados"]).reshape(-1,1))
Out[23]:
In [24]:
prediction_valid_linreg=lin_reg.predict(np.array(valid_ml["Fecha"]).reshape(-1,1))
In [25]:
model_scores.append(np.sqrt(mean_squared_error(valid_ml["Acum_confirmados"],prediction_valid_linreg)))
print("Error del cuadrado medio de la raíz para la regresión lineal en Medellín: ",np.sqrt(mean_squared_error(valid_ml["Confirmados"],prediction_valid_linreg)))
In [26]:
plt.figure(figsize=(11,6))
prediction_linreg=lin_reg.predict(np.array(df_Nuevo["Fecha"]).reshape(-1,1))
linreg_output=[]
for i in range(prediction_linreg.shape[0]):
linreg_output.append(prediction_linreg[i][0])
fig=go.Figure()
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_confirmados"],
mode='lines+markers',name="Datos de entrenamiento para casos confirmados"))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=linreg_output,
mode='lines',name="Regresión lineal de mejor ajuste",
line=dict(color='black', dash='dot')))
fig.update_layout(title="Casos confirmados Predicción de regresión lineal",
xaxis_title="Fecha",yaxis_title="Confirmados",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
Regresión polinómica para la prediccción¶
In [27]:
train_ml=df_Nuevo.iloc[:int(df_Nuevo.shape[0]*0.96)]
valid_ml=df_Nuevo.iloc[int(df_Nuevo.shape[0]*0.96):]
In [28]:
poly = PolynomialFeatures(degree = 4)
In [29]:
train_poly=poly.fit_transform(np.array(train_ml["Fecha"]).reshape(-1,1))
valid_poly=poly.fit_transform(np.array(valid_ml["Fecha"]).reshape(-1,1))
y=train_ml["Acum_confirmados"]
In [30]:
linreg=LinearRegression(normalize=True)
linreg.fit(train_poly,y)
Out[30]:
In [31]:
prediction_poly=linreg.predict(valid_poly)
rmse_poly=np.sqrt(mean_squared_error(valid_ml["Acum_confirmados"],prediction_poly))
model_scores.append(rmse_poly)
print("Error de la media cuadrática de la raíz para la regresión polinómica para Medellín: ",rmse_poly)
In [32]:
comp_data=poly.fit_transform(np.array(df_Nuevo["Fecha"]).reshape(-1,1))
plt.figure(figsize=(11,6))
predictions_poly=linreg.predict(comp_data)
fig=go.Figure()
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_confirmados"],
mode='lines+markers',name="Datos de entrenamiento para casos confirmados"))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=predictions_poly,
mode='lines',name="El mejor ajuste de la regresión polinómica",
line=dict(color='black', dash='dot')))
fig.update_layout(title="Casos confirmados Predicción de regresión polinómica en Medellín",
xaxis_title="Fecha",yaxis_title="Acum_confirmados",
legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
In [33]:
new_prediction_poly=[]
for i in range(1,18):
new_date_poly=poly.fit_transform(np.array(df_Nuevo["Fecha"].max()+i).reshape(-1,1))
new_prediction_poly.append(linreg.predict(new_date_poly)[0])
Modelo de Máquina de Vectores de Soporte¶
In [34]:
train_ml=df_Nuevo.iloc[:int(df_Nuevo.shape[0]*0.96)]
valid_ml=df_Nuevo.iloc[int(df_Nuevo.shape[0]*0.96):]
In [35]:
#Iniciando el modelo de SVR
svm=SVR(C=1,degree=2,kernel='poly',epsilon=0.01)
In [36]:
#Modelo de ajuste en los datos de entrenamiento
svm.fit(np.array(train_ml["Fecha"]).reshape(-1,1),np.array(train_ml["Acum_confirmados"]).reshape(-1,1))
Out[36]:
In [37]:
prediction_valid_svm=svm.predict(np.array(valid_ml["Fecha"]).reshape(-1,1))
In [38]:
model_scores.append(np.sqrt(mean_squared_error(valid_ml["Acum_confirmados"],prediction_valid_svm)))
print("Error del cuadrado medio de la raíz para SVM en Medellín: ",np.sqrt(mean_squared_error(valid_ml["Acum_confirmados"],prediction_valid_svm)))
In [39]:
plt.figure(figsize=(11,6))
prediction_svm=svm.predict(np.array(df_Nuevo["Fecha"]).reshape(-1,1))
fig=go.Figure()
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=df_Nuevo["Acum_confirmados"],
mode='lines+markers',name="Datos de entrenamiento para casos confirmados"))
fig.add_trace(go.Scatter(x=df_Nuevo.index, y=prediction_svm,
mode='lines',name="SVM adecuado",
line=dict(color='black', dash='dot')))
fig.update_layout(title="Casos confirmados usando el SVM para Medellín",
xaxis_title="Fecha",yaxis_title="Casos Confirmados",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
In [40]:
new_date=[]
new_prediction_lr=[]
new_prediction_svm=[]
for i in range(1,18):
new_date.append(df_Nuevo.index[-1]+timedelta(days=i))
new_prediction_lr.append(lin_reg.predict(np.array(df_Nuevo["Fecha"].max()+i).reshape(-1,1))[0][0])
new_prediction_svm.append(svm.predict(np.array(df_Nuevo["Fecha"].max()+i).reshape(-1,1))[0])
In [41]:
pd.set_option('display.float_format', lambda x: '%.6f' % x)
model_predictions=pd.DataFrame(zip(new_date,new_prediction_lr,new_prediction_poly,new_prediction_svm),
columns=["Fecha","Regresión Lineal","Regresión Polinomial","SVM"])
model_predictions.head()
Out[41]:
Método Holt¶
In [42]:
model_train=df_Nuevo.iloc[:int(df_Nuevo.shape[0]*0.96)]
valid=df_Nuevo.iloc[int(df_Nuevo.shape[0]*0.96):]
y_pred=valid.copy()
In [43]:
holt=Holt(np.asarray(model_train["Acum_confirmados"])).fit(smoothing_level=0.2, smoothing_slope=1.8,optimized=False)
In [44]:
y_pred["Holt"]=holt.forecast(len(valid))
model_scores.append(np.sqrt(mean_squared_error(y_pred["Acum_confirmados"],y_pred["Holt"])))
print("Error del cuadrado medio del HOLT: ",np.sqrt(mean_squared_error(y_pred["Acum_confirmados"],y_pred["Holt"])))
In [45]:
fig=go.Figure()
fig.add_trace(go.Scatter(x=model_train.index, y=model_train["Acum_confirmados"],
mode='lines+markers',name="Train Data for Confirmed Cases"))
fig.add_trace(go.Scatter(x=valid.index, y=valid["Acum_confirmados"],
mode='lines+markers',name="Datos de validación para datos confirmados",))
fig.add_trace(go.Scatter(x=valid.index, y=y_pred["Holt"],
mode='lines+markers',name="Predicción de casos Confirmados",))
fig.update_layout(title="Casos Confirmados usando el modelo de Predicción HOLT",
xaxis_title="Fecha",yaxis_title="Casos Confirmados",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
In [46]:
holt_new_date=[]
holt_new_prediction=[]
for i in range(1,18):
holt_new_date.append(df_Nuevo.index[-1]+timedelta(days=i))
holt_new_prediction.append(holt.forecast((len(valid)+i))[-1])
model_predictions["Modelo de predicción HOLT"]=holt_new_prediction
model_predictions.head()
Out[46]:
Modelo MA (Usando Auto ARIMA)¶
In [47]:
model_train=df_Nuevo.iloc[:int(df_Nuevo.shape[0]*0.96)]
valid=df_Nuevo.iloc[int(df_Nuevo.shape[0]*0.96):]
y_pred=valid.copy()
In [48]:
model_ma= auto_arima(model_train["Acum_confirmados"],trace=True, error_action='ignore', start_p=0,start_q=0,max_p=0,max_q=5,
suppress_warnings=True,stepwise=False,seasonal=False)
model_ma.fit(model_train["Acum_confirmados"])
Out[48]:
In [49]:
prediction_ma=model_ma.predict(len(valid))
y_pred["MA Model Prediction"]=prediction_ma
In [50]:
model_scores.append(np.sqrt(mean_squared_error(valid["Acum_confirmados"],prediction_ma)))
print("Error Cuadrático Medio Modelo MA: ",np.sqrt(mean_squared_error(valid["Acum_confirmados"],prediction_ma)))
In [51]:
fig=go.Figure()
fig.add_trace(go.Scatter(x=model_train.index, y=model_train["Acum_confirmados"],
mode='lines+markers',name="Datos de entrenamiento para casos Confirmados"))
fig.add_trace(go.Scatter(x=valid.index, y=valid["Acum_confirmados"],
mode='lines+markers',name="Datos de Validación para casos confirmados",))
fig.add_trace(go.Scatter(x=valid.index, y=y_pred["MA Model Prediction"],
mode='lines+markers',name="Predicción de casos confirmados",))
fig.update_layout(title="Predicción de casos confirmados para el modelo MA",
xaxis_title="Fecha",yaxis_title="Casos Confirmados",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
In [52]:
MA_model_new_prediction=[]
for i in range(1,18):
MA_model_new_prediction.append(model_ma.predict(len(valid)+i)[-1])
model_predictions["Modelo MA"]=MA_model_new_prediction
model_predictions.head()
Out[52]:
Modelo ARIMA (Usando Auto-ARIMA)¶
In [53]:
model_train=df_Nuevo.iloc[:int(df_Nuevo.shape[0]*0.96)]
valid=df_Nuevo.iloc[int(df_Nuevo.shape[0]*0.96):]
y_pred=valid.copy()
In [54]:
model_arima= auto_arima(model_train["Acum_confirmados"],trace=True, error_action='ignore', start_p=1,start_q=1,max_p=3,max_q=3,
suppress_warnings=True,stepwise=False,seasonal=False)
model_arima.fit(model_train["Acum_confirmados"])
Out[54]:
In [55]:
prediction_arima=model_arima.predict(len(valid))
y_pred["ARIMA Model Prediction"]=prediction_arima
In [56]:
model_scores.append(np.sqrt(mean_squared_error(valid["Acum_confirmados"],prediction_arima)))
print("Error Cuadrático Medio Modelo ARIMA: ",np.sqrt(mean_squared_error(valid["Acum_confirmados"],prediction_arima)))
In [57]:
fig=go.Figure()
fig.add_trace(go.Scatter(x=model_train.index, y=model_train["Acum_confirmados"],
mode='lines+markers',name="Datos de entrenamiento para casos confirmados"))
fig.add_trace(go.Scatter(x=valid.index, y=valid["Acum_confirmados"],
mode='lines+markers',name="Datos de validación para datos confirmados",))
fig.add_trace(go.Scatter(x=valid.index, y=y_pred["ARIMA Model Prediction"],
mode='lines+markers',name="Predicción de casos confirmados",))
fig.update_layout(title="Predicción de casos confirmados con el modelo ARIMA de Medellín",
xaxis_title="Fecha",yaxis_title="Acum_confirmados",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
In [58]:
ARIMA_model_new_prediction=[]
for i in range(1,18):
ARIMA_model_new_prediction.append(model_arima.predict(len(valid)+i)[-1])
model_predictions["ARIMA Model Prediction"]=ARIMA_model_new_prediction
model_predictions.head()
Out[58]:
Modelo SARIMA (Usanto Auto ARIMA)¶
In [59]:
model_sarima= auto_arima(model_train["Acum_confirmados"],trace=True, error_action='ignore',
start_p=0,start_q=0,max_p=2,max_q=2,m=7,
suppress_warnings=True,stepwise=True,seasonal=True)
model_sarima.fit(model_train["Acum_confirmados"])
Out[59]:
In [60]:
prediction_sarima=model_sarima.predict(len(valid))
y_pred["SARIMA Model Prediction"]=prediction_sarima
In [61]:
model_scores.append(np.sqrt(mean_squared_error(y_pred["Acum_confirmados"],y_pred["SARIMA Model Prediction"])))
print("Error Cuadrático Medio Modelo SARIMA: ",np.sqrt(mean_squared_error(y_pred["Acum_confirmados"],y_pred["SARIMA Model Prediction"])))
In [62]:
fig=go.Figure()
fig.add_trace(go.Scatter(x=model_train.index, y=model_train["Acum_confirmados"],
mode='lines+markers',name="Datos de entrenamiento para casos confirmados"))
fig.add_trace(go.Scatter(x=valid.index, y=valid["Acum_confirmados"],
mode='lines+markers',name="Datos de validación para casos confirmados",))
fig.add_trace(go.Scatter(x=valid.index, y=y_pred["SARIMA Model Prediction"],
mode='lines+markers',name="Predicción para casos confirmados",))
fig.update_layout(title="Predicción de datos confirmados modelo SARIMA en Medellín",
xaxis_title="Fecha",yaxis_title="Casos Confirmados",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
In [63]:
SARIMA_model_new_prediction=[]
for i in range(1,18):
SARIMA_model_new_prediction.append(model_sarima.predict(len(valid)+i)[-1])
model_predictions["Modelo SARIMA"]=SARIMA_model_new_prediction
model_predictions.head()
Out[63]:
Modelo Prophet¶
In [64]:
prophet_c=Prophet(interval_width=0.75,weekly_seasonality=True,)
prophet_confirmed=pd.DataFrame(zip(list(df_Nuevo.index),list(df_Nuevo["Acum_confirmados"])),columns=['ds','y'])
In [65]:
prophet_c.fit(prophet_confirmed)
Out[65]:
In [66]:
forecast_c=prophet_c.make_future_dataframe(periods=17)
forecast_confirmed=forecast_c.copy()
In [67]:
confirmed_forecast=prophet_c.predict(forecast_c)
In [68]:
model_scores.append(np.sqrt(mean_squared_error(df_Nuevo["Acum_confirmados"],confirmed_forecast['yhat'].head(df_Nuevo.shape[0]))))
print("Error Cuadrático Medio Modelo Prophet: ",np.sqrt(mean_squared_error(df_Nuevo["Acum_confirmados"],confirmed_forecast['yhat'].head(df_Nuevo.shape[0]))))
In [69]:
print(prophet_c.plot(confirmed_forecast))
In [70]:
print(prophet_c.plot_components(confirmed_forecast))
In [71]:
model_names=["Linear Regression","Polynomial Regression","Support Vector Machine Regressor","Holt's Linear",
"Auto Regressive Model (AR)","Moving Average Model (MA)","ARIMA Model","SARIMA Model","Facebook's Prophet Model"]
model_summary=pd.DataFrame(zip(model_names,model_scores),columns=["Model Name","Root Mean Squared Error"]).sort_values(["Root Mean Squared Error"])
model_summary
Out[71]:
In [72]:
model_predictions["Prophet's Prediction"]=list(confirmed_forecast["yhat"].tail(17))
model_predictions["Prophet's Upper Bound"]=list(confirmed_forecast["yhat_upper"].tail(17))
model_predictions.head()
Out[72]:
CASOS FALLECIDOS¶
Modelo ARIMA (Usando Auto-ARIMA)¶
In [73]:
model_train=df_Nuevo.iloc[:int(df_Nuevo.shape[0]*0.96)]
valid=df_Nuevo.iloc[int(df_Nuevo.shape[0]*0.96):]
y_pred=valid.copy()
In [74]:
model_arima= auto_arima(model_train["Acum_muertos"],trace=True, error_action='ignore', start_p=1,start_q=1,max_p=3,max_q=3,
suppress_warnings=True,stepwise=False,seasonal=False)
model_arima.fit(model_train["Acum_muertos"])
Out[74]:
In [75]:
prediction_arima=model_arima.predict(len(valid))
y_pred["ARIMA Model Prediction"]=prediction_arima
In [76]:
model_scores.append(np.sqrt(mean_squared_error(valid["Acum_muertos"],prediction_arima)))
print("Error Cuadrático Medio Modelo ARIMA: ",np.sqrt(mean_squared_error(valid["Acum_muertos"],prediction_arima)))
In [77]:
fig=go.Figure()
fig.add_trace(go.Scatter(x=model_train.index, y=model_train["Acum_muertos"],
mode='lines+markers',name="Datos de entrenamiento para casos fallecidos"))
fig.add_trace(go.Scatter(x=valid.index, y=valid["Acum_muertos"],
mode='lines+markers',name="Datos de validación para datos fallecidos",))
fig.add_trace(go.Scatter(x=valid.index, y=y_pred["ARIMA Model Prediction"],
mode='lines+markers',name="Predicción de casos fallecidos",))
fig.update_layout(title="Predicción de casos fallecidos con el modelo ARIMA de Medellín",
xaxis_title="Fecha",yaxis_title="Acum_muertos",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
In [78]:
ARIMA_model_new_prediction=[]
for i in range(1,18):
ARIMA_model_new_prediction.append(model_arima.predict(len(valid)+i)[-1])
In [79]:
pd.DataFrame(zip(new_date,ARIMA_model_new_prediction),columns=["Casos de Muertes","Modelo de Predicción Modelo Arima"]).head()
Out[79]:
Modelo Prophet¶
In [80]:
prophet_c=Prophet(interval_width=0.75,weekly_seasonality=True,)
prophet_confirmed=pd.DataFrame(zip(list(df_Nuevo.index),list(df_Nuevo["Acum_muertos"])),columns=['ds','y'])
In [81]:
prophet_c.fit(prophet_confirmed)
Out[81]:
In [82]:
forecast_c=prophet_c.make_future_dataframe(periods=17)
forecast_confirmed=forecast_c.copy()
In [83]:
confirmed_forecast=prophet_c.predict(forecast_c)
In [84]:
model_scores.append(np.sqrt(mean_squared_error(df_Nuevo["Acum_muertos"],confirmed_forecast['yhat'].head(df_Nuevo.shape[0]))))
print("Error Cuadrático Medio Modelo Prophet: ",np.sqrt(mean_squared_error(df_Nuevo["Acum_muertos"],confirmed_forecast['yhat'].head(df_Nuevo.shape[0]))))
In [85]:
print(prophet_c.plot(confirmed_forecast))
In [86]:
print(prophet_c.plot_components(confirmed_forecast))
CASOS RECUPERADOS¶
Modelo ARIMA (Usando Auto-ARIMA)¶
In [87]:
model_train=df_Nuevo.iloc[:int(df_Nuevo.shape[0]*0.96)]
valid=df_Nuevo.iloc[int(df_Nuevo.shape[0]*0.96):]
y_pred=valid.copy()
In [88]:
model_arima= auto_arima(model_train["Acum_Recuperados"],trace=True, error_action='ignore', start_p=1,start_q=1,max_p=3,max_q=3,
suppress_warnings=True,stepwise=False,seasonal=False)
model_arima.fit(model_train["Acum_Recuperados"])
Out[88]:
In [89]:
prediction_arima=model_arima.predict(len(valid))
y_pred["ARIMA Model Prediction"]=prediction_arima
In [90]:
model_scores.append(np.sqrt(mean_squared_error(valid["Acum_Recuperados"],prediction_arima)))
print("Error Cuadrático Medio Modelo ARIMA: ",np.sqrt(mean_squared_error(valid["Acum_Recuperados"],prediction_arima)))
In [91]:
fig=go.Figure()
fig.add_trace(go.Scatter(x=model_train.index, y=model_train["Acum_Recuperados"],
mode='lines+markers',name="Datos de entrenamiento para casos recuperados"))
fig.add_trace(go.Scatter(x=valid.index, y=valid["Acum_Recuperados"],
mode='lines+markers',name="Datos de validación para datos recuperados",))
fig.add_trace(go.Scatter(x=valid.index, y=y_pred["ARIMA Model Prediction"],
mode='lines+markers',name="Predicción de casos recuperados",))
fig.update_layout(title="Predicción de casos recuperados con el modelo ARIMA de Medellín",
xaxis_title="Fecha",yaxis_title="Acum_Recuperados",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
In [92]:
ARIMA_model_new_prediction=[]
for i in range(1,18):
ARIMA_model_new_prediction.append(model_arima.predict(len(valid)+i)[-1])
In [93]:
pd.DataFrame(zip(new_date,ARIMA_model_new_prediction),columns=["Recuperados","Predicción Modelo ARIMA"]).head()
Out[93]:
Modelo Prophet¶
In [94]:
prophet_c=Prophet(interval_width=0.75,weekly_seasonality=True,)
prophet_confirmed=pd.DataFrame(zip(list(df_Nuevo.index),list(df_Nuevo["Acum_Recuperados"])),columns=['ds','y'])
In [95]:
prophet_c.fit(prophet_confirmed)
Out[95]:
In [96]:
forecast_c=prophet_c.make_future_dataframe(periods=17)
forecast_confirmed=forecast_c.copy()
In [97]:
confirmed_forecast=prophet_c.predict(forecast_c)
In [98]:
model_scores.append(np.sqrt(mean_squared_error(df_Nuevo["Acum_Recuperados"],confirmed_forecast['yhat'].head(df_Nuevo.shape[0]))))
print("Error Cuadrático Medio Modelo Prophet: ",np.sqrt(mean_squared_error(df_Nuevo["Acum_Recuperados"],confirmed_forecast['yhat'].head(df_Nuevo.shape[0]))))
In [99]:
print(prophet_c.plot(confirmed_forecast))
In [100]:
print(prophet_c.plot_components(confirmed_forecast))
CASOS ACTIVOS¶
Modelo ARIMA (Usando Auto-ARIMA)¶
In [103]:
model_train=df_Nuevo.iloc[:int(df_Nuevo.shape[0]*0.96)]
valid=df_Nuevo.iloc[int(df_Nuevo.shape[0]*0.96):]
y_pred=valid.copy()
In [104]:
model_arima= auto_arima(model_train["Acum_Activos"],trace=True, error_action='ignore', start_p=1,start_q=1,max_p=3,max_q=3,
suppress_warnings=True,stepwise=False,seasonal=False)
model_arima.fit(model_train["Acum_Activos"])
Out[104]:
In [105]:
prediction_arima=model_arima.predict(len(valid))
y_pred["ARIMA Model Prediction"]=prediction_arima
In [106]:
model_scores.append(np.sqrt(mean_squared_error(valid["Acum_Activos"],prediction_arima)))
print("Error Cuadrático Medio Modelo ARIMA: ",np.sqrt(mean_squared_error(valid["Acum_Activos"],prediction_arima)))
In [107]:
fig=go.Figure()
fig.add_trace(go.Scatter(x=model_train.index, y=model_train["Acum_Activos"],
mode='lines+markers',name="Datos de entrenamiento para casos activos"))
fig.add_trace(go.Scatter(x=valid.index, y=valid["Acum_Activos"],
mode='lines+markers',name="Datos de validación para datos activos",))
fig.add_trace(go.Scatter(x=valid.index, y=y_pred["ARIMA Model Prediction"],
mode='lines+markers',name="Predicción de casos activos",))
fig.update_layout(title="Predicción de casos activos con el modelo ARIMA de Medellín",
xaxis_title="Fecha",yaxis_title="Acum_muertos",legend=dict(x=0,y=1,traceorder="normal"))
fig.show()
In [108]:
ARIMA_model_new_prediction=[]
for i in range(1,18):
ARIMA_model_new_prediction.append(model_arima.predict(len(valid)+i)[-1])
In [109]:
pd.DataFrame(zip(new_date,ARIMA_model_new_prediction),columns=["Activos","Predicción Modelo ARIMA"]).head()
Out[109]:
Modelo Prophet¶
In [110]:
prophet_c=Prophet(interval_width=0.75,weekly_seasonality=True,)
prophet_confirmed=pd.DataFrame(zip(list(df_Nuevo.index),list(df_Nuevo["Acum_Activos"])),columns=['ds','y'])
In [111]:
prophet_c.fit(prophet_confirmed)
Out[111]:
In [112]:
forecast_c=prophet_c.make_future_dataframe(periods=17)
forecast_confirmed=forecast_c.copy()
In [113]:
confirmed_forecast=prophet_c.predict(forecast_c)
In [114]:
model_scores.append(np.sqrt(mean_squared_error(df_Nuevo["Acum_Activos"],confirmed_forecast['yhat'].head(df_Nuevo.shape[0]))))
print("Error Cuadrático Medio Modelo Prophet: ",np.sqrt(mean_squared_error(df_Nuevo["Acum_Activos"],confirmed_forecast['yhat'].head(df_Nuevo.shape[0]))))
In [115]:
print(prophet_c.plot(confirmed_forecast))
In [116]:
print(prophet_c.plot_components(confirmed_forecast))
